package yygh.user.Service.imp;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import yygh.hospital.enums.AuthStatusEnum;
import yygh.hospital.model.user.Patient;
import yygh.hospital.model.user.UserInfo;
import yygh.hospital.vo.user.LoginVo;
import yygh.hospital.vo.user.UserAuthVo;
import yygh.hospital.vo.user.UserInfoQueryVo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import yygh.common.execption.HospitalException;
import yygh.common.helper.JwtHelper;
import yygh.common.result.ResultCodeEnum;

import yygh.user.Service.PatientService;
import yygh.user.Service.UserInfoService;
import yygh.user.mapper.UserInfoMapper;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class UserInfoServiceImp  extends ServiceImpl<UserInfoMapper,UserInfo>  implements  UserInfoService {
    @Autowired
    UserInfoMapper userInfoMapper;

    @Autowired
    RedisTemplate<String,String> redisTemplate;

    @Autowired
    PatientService patientService;

    //Service实现手机号登录功能
    @Override
    public Map<String, Object> login(LoginVo loginVo) {
        //1、从loginVo中获取手机号和验证码
        String phone = loginVo.getPhone();
        String code = loginVo.getCode();
        //2、判断手机号和验证吗是否为空
        if (StringUtils.isEmpty(phone)||StringUtils.isEmpty(code)){
            throw  new HospitalException(ResultCodeEnum.PARAM_ERROR);
        }
        //3、判断手机号的验证码和输入的验证码是否一致
            //redis中的code
        String redisCode = redisTemplate.opsForValue().get(phone);
        if (!code.equals(redisCode)){
            throw new HospitalException(ResultCodeEnum.CODE_ERROR);
        }
        //4、验证码为一致后，判断当前是否为第一次登录
            //利用mybatis-plus进行查询
            QueryWrapper<UserInfo> queryWrapper=new QueryWrapper<>();
            queryWrapper.eq("phone",phone);
             UserInfo userInfo = userInfoMapper.selectOne(queryWrapper);
        //如果为第一次登录，则进行用户的自动注册，将手机号存入到数据库中
            if (userInfo==null){
                //进行注册
                 userInfo=new UserInfo();
                userInfo.setPhone(phone);
                userInfo.setName("");
                userInfo.setStatus(1);
                baseMapper.insert(userInfo);
            }
            //如果不是第一次登录，则进行校验，校验当前用户是否被禁用
            if (userInfo.getStatus()==0){
                throw  new HospitalException(ResultCodeEnum.LOGIN_DISABLED_ERROR);
            }
        //5、返回登录信息，以map形式封装
            //返回登录用户名
            //返回token信息
            Map<String,Object> resultMap=new HashMap<>();
              String name = userInfo.getName();
              if (StringUtils.isEmpty(name)){
                      name=userInfo.getNickName();
             }
             if (StringUtils.isEmpty(name)){
                     name=userInfo.getPhone();
            }
                resultMap.put("name",name);
        //获取token信息，进行封装
        //整合JWT依赖，生成一个token信息（登陆完成后）
        String token = JwtHelper.createToken(userInfo.getId(), name);
        resultMap.put("token",token);

        return  resultMap;
    }

    //Service层，实现用户信息的完成，根据传入的userAuthVo实现对userInfo的更新
    @Override
    public void userAuth(Long userId, UserAuthVo userAuthVo) {

        //根据userId用户编号获取对应的用户
        UserInfo userInfo = userInfoMapper.selectById(userId);

        //根据userAuthVo的相关参数对userInfo对象进行更新
        userInfo.setName(userAuthVo.getName());
        userInfo.setCertificatesType(userAuthVo.getCertificatesType());
        userInfo.setCertificatesNo(userAuthVo.getCertificatesNo());
        userInfo.setCertificatesUrl(userAuthVo.getCertificatesUrl());
        //将用户状态设置为认证中
        userInfo.setStatus(AuthStatusEnum.AUTH_RUN.getStatus());

        //对设置完属性的userInfo进行更新
        userInfoMapper.updateById(userInfo);
    }


    /**
     *  后台管理系统进行用户管理相关Service层操作
     * @param page
     * @param userInfoQueryVo
     * @return
     */
    //Service层实现条件分页查询
    @Override
    public IPage<UserInfo> selectPage(Page<UserInfo> page, UserInfoQueryVo userInfoQueryVo) {
        //根据查询条件userInfoQueryVo获取条件值
        String name = userInfoQueryVo.getKeyword(); //用户名称
        Integer status = userInfoQueryVo.getStatus();//用户状态
        Integer authStatus = userInfoQueryVo.getAuthStatus(); //认证状态
        String createTimeBegin = userInfoQueryVo.getCreateTimeBegin(); //开始时间
        String createTimeEnd = userInfoQueryVo.getCreateTimeEnd(); //结束时间

        //根据条件值是否为空进行相关的封装
        QueryWrapper<UserInfo> queryWrapper=new QueryWrapper<>();

        if (!StringUtils.isEmpty(name)){
            queryWrapper.like("name",name);
        }
        if (!StringUtils.isEmpty(status)) {
            queryWrapper.eq("status", status);
        }
        if (!StringUtils.isEmpty(authStatus)) {
            queryWrapper.eq("auth_status", authStatus);
        }
        if (!StringUtils.isEmpty(createTimeBegin)) {
            queryWrapper.ge("create_time", createTimeBegin);
        }
        if (!StringUtils.isEmpty(createTimeEnd)) {
            queryWrapper.le("create_time", createTimeEnd);
        }
        //进行条件分页查询。
        IPage<UserInfo> userInfoPage = userInfoMapper.selectPage(page, queryWrapper);

        //封装对应的值，将其状态status的具体中文解释展现，如1-锁定，0-正常
        userInfoPage.getRecords().stream().forEach(item->{
            this.packegParam(item);
        });
        return  userInfoPage;
    }

    //Service层，实现用户的具体信息展示，包含用户信息+所有的就诊人信息
    @Override
    public Map<String, Object> show(Long userId) {
        Map<String,Object> result=new HashMap<>();
        //首先根据用户id查询到对应的userInfo对象,并对该对象进行信息封装
        UserInfo userInfo = userInfoMapper.selectById(userId);
        this.packegParam(userInfo);
        result.put("userInfo",userInfo);
        //查询该用户对象下的所有就诊人信息
        List<Patient> patientList = patientService.findAllByUserId(userId);
        result.put("patientList",patientList);
        return  result;
    }

    //Service层，实现用户的锁定与解锁,0代表锁定，1代表未绑定
    @Override
    public void lock(Long userId, Integer status) {
        if (status.intValue() == 1 || status.intValue() == 0) {
            UserInfo userInfo = userInfoMapper.selectById(userId);
            userInfo.setStatus(status);
            userInfoMapper.updateById(userInfo);
        }
    }

    //Service层，实现用户的认证，认证状态（0：未认证 1：认证中 2：认证成功 -1：认证失败）
    @Override
    public void approval(Long userId, Integer authStatus) {
        if (authStatus.intValue() == 2 || authStatus.intValue() ==-1) {
            UserInfo userInfo = userInfoMapper.selectById(userId);
            userInfo.setAuthStatus(authStatus);
            userInfoMapper.updateById(userInfo);
        }
    }

        //封装用户的状态信息
        private UserInfo packegParam(UserInfo userInfo) {
            //处理用户的状态编码
            userInfo.getParam().put("authStatusString",AuthStatusEnum.getStatusNameByStatus(userInfo.getAuthStatus()));
            //处理用户的锁定状态
            String statusString=userInfo.getStatus().intValue()==0?"锁定":"正常";
            userInfo.getParam().put("statusString",statusString);
            return userInfo;
        }

}
